package com.wwl.cms.utils.designModeTest.singleton;

import java.util.Calendar;
import java.util.HashMap;

/**
 * @author wwl
 * @version 1.0
 * @date 2021/9/2 15:06
 * @description:
 */
public class SingletonTest1 extends Thread {
    volatile Boolean flag = false;
    int i = 0;

    public void run() {
        while (!flag) {
            i++;
        }
    }

    public static void main(String[] args) throws Exception {
        Calendar calendar = Calendar.getInstance();
        HashMap hashMap = new HashMap();

        SingletonTest1 vt = new SingletonTest1();
        vt.start();
        Thread.sleep(2000);
        vt.flag = true;
        System.out.println("stope" + vt.i);
    }
}

//饿汉模式(静态变量)
/*class Singleton {
    //1.构造私有方法，外部能new
    private Singleton() {
    }
    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}*/
/*//饿汉模式(静态代码块)
class Singleton2 {
    //1.构造私有方法，外部能能new
    private Singleton2() {
    }
    //2.本类内部创建对象实例
    private  static Singleton2 instance ;
    static {//在静态代码块中，创建单例对象
        instance = new Singleton2();
    }
    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton2 getInstance() {
        return instance;
    }
}*/
//懒汉模式(线程不安全)
 /*class Singleton{
    //1.构造私有方法，外部能能new
    private static Singleton instance ;

    private Singleton(){}

    //3.提供一个公有的静态方法，当使用到该方法时，才去创建
    public static Singleton getInstance() {
        if (instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}*/
//懒汉模式(线程安全,同步方法)
/*class Singleton{
    //1.构造私有方法，外部能能new
    private static Singleton instance ;

    private Singleton(){}

    //3.提供一个公有的静态方法，加入同步处理代码，解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}*/
//懒汉模式(线程安全,同步代码块)
/*class Singleton{
    //1.构造私有方法，外部能能new
    private static Singleton instance ;
    private Singleton(){}
    //3.提供一个公有的静态方法，加入同步处理代码，解决线程安全问题
    public static  Singleton getInstance() {
        if (instance==null){
            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}*/
//双重检查
/*class Singleton {
    //1.构造私有方法，外部能能new
    private static volatile Singleton instance;

    private Singleton() {
    }
    //3.提供一个公有的静态方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    //同时保证效率，推荐使用
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}*/
//静态内部类完成，推荐使用
class Singleton {
    //1.构造私有方法，外部能能new
    private static volatile Singleton instance;
    //构造器私有化
    private Singleton() { }
    //写一个静态内部类，该类中有一个静态属性
    private static class SingletonInstance{
        private static final Singleton INGLETON = new Singleton();
    }
    //3.提供一个公有的静态方法，直接返回
    public static synchronized Singleton getInstance() {
       return SingletonInstance.INGLETON;
    }
}

